import router from './router'
import store from './store'
import { Message } from 'element-ui'
import NProgress from 'nprogress'
import 'nprogress/nprogress.css'
import { getToken, removeToken } from '@/utils/auth'
import { isRelogin } from '@/utils/request'
import { userStorage } from '@/utils/storage'

NProgress.configure({ showSpinner: false })

const whiteList = ['/login', '/register', '/aggregation-login', '/404', '/401']

router.beforeEach((to, from, next) => {
  NProgress.start()
  const token = getToken()

  if (token) {
    // 有token
    to.meta.title && store.dispatch('settings/setTitle', to.meta.title)

    if (to.path === '/login' || to.path === '/aggregation-login') {
      // 已登录，根据用户类型跳转到对应的首页
      const userType = store.getters.userType
      // 如果 userType 为空，说明可能是退出登录后的残留 token，直接允许访问登录页
      if (!userType) {
        // 清除可能残留的 token
        removeToken()
        next()
        NProgress.done()
        return
      }
      const roleDashboardMap = {
        5: '/admin/dashboard',    // 总公司
        4: '/agent/dashboard',    // 区域代理
        2: '/salesman/dashboard', // 业务员
        3: '/merchant/dashboard'  // 商家
      }
      const redirectPath = roleDashboardMap[userType] || '/admin/dashboard'
      next({ path: redirectPath })
      NProgress.done()
    } else if (whiteList.indexOf(to.path) !== -1) {
      // 在白名单中，直接通过
      next()
    } else {
      // 需要权限验证
      const userType = store.getters.userType
      const routes = store.getters.permission_routes

      Logger.log('权限守卫检查', {
        token: token ? '已存在' : '不存在',
        userType,
        userTypeType: typeof userType,
        routesCount: routes.length,
        rolesCount: store.getters.roles.length
      })

      // 调试：检查业务员路由
      if (userType === 2) {
        const salesmanRoutes = routes.filter(route => route.path === '/salesman')
        Logger.log('业务员路由检查', {
          salesmanRoutes: salesmanRoutes.length,
          hasChildren: salesmanRoutes.length > 0 && salesmanRoutes[0].children
        })
      }

      // 如果token存在但userType为空，说明页面刷新了，尝试从存储中恢复用户信息
      if (token && !userType) {
        Logger.info('检测到token但userType为空，尝试从加密存储中恢复用户信息')

        // 尝试从加密存储恢复用户信息
        const storedUserType = userStorage.getUserType()
        const storedUserPhone = userStorage.getUserPhone()

        if (storedUserType && storedUserPhone) {
          Logger.info('从加密存储恢复用户信息', { userType: storedUserType })
          // 恢复用户信息到store
          store.commit('SET_USER_TYPE', parseInt(storedUserType))
          store.commit('SET_USER_PHONE', storedUserPhone)

          // 恢复token到store（重要！）
          store.commit('SET_TOKEN', token)

          // 尝试从加密存储恢复用户详情
          const storedUserDetail = userStorage.getUserDetail()
          if (storedUserDetail) {
            try {
              store.commit('SET_USER_INFO', storedUserDetail)
              if (storedUserDetail.id) {
                store.commit('SET_ID', storedUserDetail.id)
              }
              // 如果用户详情中包含头像，恢复头像
              if (storedUserDetail.avatar && storedUserDetail.avatar.trim()) {
                store.commit('SET_AVATAR', storedUserDetail.avatar)
                Logger.info('从加密缓存恢复用户头像:', storedUserDetail.avatar)
              }
              Logger.info('从加密缓存恢复用户详情成功')
            } catch (error) {
              Logger.error('解析用户详情缓存失败', error)
            }
          }

          // 尝试从加密存储恢复头像（优先使用）
          const storedAvatar = userStorage.getUserAvatar()
          if (storedAvatar && storedAvatar.trim()) {
            // 只有当头像不是默认头像路径时才恢复
            // require()的结果通常是模块ID，不会是字符串URL，所以可以直接恢复
            if (!storedAvatar.includes('@/assets/images/profile.jpg')) {
              store.commit('SET_AVATAR', storedAvatar)
              Logger.info('从加密存储恢复用户头像:', storedAvatar)
            }
          }

          // 继续权限检查
          const userType = parseInt(storedUserType)
          if ([2, 3, 4, 5].includes(userType)) {
            // 调用GetInfo获取最新的用户信息（包括头像）
            store.dispatch('GetInfo').then(() => {
              if (routes.length === 0) {
                // 生成路由（路由已在GenerateRoutes内部添加，无需重复添加）
                store.dispatch('GenerateRoutes').then(accessRoutes => {

                  // 检查当前路径是否是角色相关的路径
                  const currentPath = to.path
                  const rolePaths = {
                    5: ['/admin/'],      // 总公司
                    4: ['/agent/'],      // 区域代理
                    2: ['/salesman/'],   // 业务员
                    3: ['/merchant/']    // 商家
                  }

                  const allowedPaths = rolePaths[userType] || []
                  const isRolePath = allowedPaths.some(pathPrefix => currentPath.startsWith(pathPrefix))

                  // 如果访问根路径或index路径，重定向到角色首页
                  if (currentPath === '/' || currentPath === '/index') {
                    const roleDashboardMap = {
                      5: '/admin/dashboard',    // 总公司
                      4: '/agent/dashboard',    // 区域代理
                      2: '/salesman/dashboard', // 业务员
                      3: '/merchant/dashboard'  // 商家
                    }
                    const redirectPath = roleDashboardMap[userType]
                    next({ path: redirectPath, replace: true })
                  } else if (isRolePath) {
                    // 如果当前路径是角色相关的路径，直接访问
                    next({ ...to, replace: true })
                  } else {
                    // 否则跳转到角色首页
                    const roleDashboardMap = {
                      5: '/admin/dashboard',    // 总公司
                      4: '/agent/dashboard',    // 区域代理
                      2: '/salesman/dashboard', // 业务员
                      3: '/merchant/dashboard'  // 商家
                    }
                    const redirectPath = roleDashboardMap[userType]
                    next({ path: redirectPath, replace: true })
                  }
                }).catch(() => {
                  next({ path: '/404' })
                })
              } else {
                // 路由已生成，检查当前路径是否与用户类型匹配
                const currentPath = to.path
                const rolePaths = {
                  5: ['/admin/'],      // 总公司
                  4: ['/agent/'],      // 区域代理
                  2: ['/salesman/'],   // 业务员
                  3: ['/merchant/']    // 商家
                }

                const allowedPaths = rolePaths[userType] || []
                const isRolePath = allowedPaths.some(pathPrefix => currentPath.startsWith(pathPrefix))

                // 如果当前路径不匹配用户类型，说明可能是上一个用户的路由，需要清除并重新生成
                if (currentPath !== '/aggregation-login' && currentPath !== '/login' && !isRolePath && currentPath !== '/' && currentPath !== '/index') {
                  Logger.warn('检测到路由与用户类型不匹配（从存储恢复后），清除旧路由和页签并重新生成', {
                    currentPath,
                    userType,
                    allowedPaths
                  })
                  // 强制清除所有页签（包括固定页签），切换角色时清除旧用户的页签
                  store.dispatch('tagsView/delAllViews', true).catch((error) => {
                    Logger.warn('清除页签失败', error)
                  })
                  // 清除旧路由状态
                  store.dispatch('permission/ResetRoutes').then(() => {
                    // 重新生成路由
                    return store.dispatch('GenerateRoutes')
                  }).then(() => {
                    // 重定向到角色首页
                    const roleDashboardMap = {
                      5: '/admin/dashboard',    // 总公司
                      4: '/agent/dashboard',    // 区域代理
                      2: '/salesman/dashboard', // 业务员
                      3: '/merchant/dashboard'  // 商家
                    }
                    const redirectPath = roleDashboardMap[userType]
                    next({ path: redirectPath, replace: true })
                  }).catch(() => {
                    next({ path: '/404' })
                  })
                  return
                }

                // 路由匹配，正常访问
                if (currentPath === '/' || currentPath === '/index') {
                  const roleDashboardMap = {
                    5: '/admin/dashboard',    // 总公司
                    4: '/agent/dashboard',    // 区域代理
                    2: '/salesman/dashboard', // 业务员
                    3: '/merchant/dashboard'  // 商家
                  }
                  const redirectPath = roleDashboardMap[userType]
                  next({ path: redirectPath, replace: true })
                } else {
                  next()
                }
              }
            }).catch(() => {
              // GetInfo失败，清除token并跳转到登录页
              store.dispatch('FedLogOut').then(() => {
                next({ path: '/aggregation-login' })
              })
            })
          } else {
            next()
          }
        } else {
          Logger.warn('无法从加密存储中恢复用户信息，清除token并跳转到聚合登录页面')
          // 清除token避免无限循环
          store.dispatch('FedLogOut').then(() => {
            next({ path: '/aggregation-login' })
          })
        }
        return
      }

      // 聚合系统用户
      if (userType && [2, 3, 4, 5].includes(userType)) {
        if (routes.length === 0) {
          // 生成路由（路由已在GenerateRoutes内部添加，无需重复添加）
          store.dispatch('GenerateRoutes').then(accessRoutes => {

            // 检查当前路径是否是角色相关的路径
            const currentPath = to.path
            const rolePaths = {
              5: ['/admin/'],      // 总公司
              4: ['/agent/'],      // 区域代理
              2: ['/salesman/'],   // 业务员
              3: ['/merchant/']    // 商家
            }

            const allowedPaths = rolePaths[userType] || []
            const isRolePath = allowedPaths.some(pathPrefix => currentPath.startsWith(pathPrefix))

            // 如果访问根路径或index路径，重定向到角色首页
            if (currentPath === '/' || currentPath === '/index') {
              const roleDashboardMap = {
                5: '/admin/dashboard',    // 总公司
                4: '/agent/dashboard',    // 区域代理
                2: '/salesman/dashboard', // 业务员
                3: '/merchant/dashboard'  // 商家
              }
              const redirectPath = roleDashboardMap[userType]
              next({ path: redirectPath, replace: true })
            } else if (isRolePath) {
              // 如果当前路径是角色相关的路径，直接访问
              next({ ...to, replace: true })
            } else {
              // 否则跳转到角色首页
              const roleDashboardMap = {
                5: '/admin/dashboard',    // 总公司
                4: '/agent/dashboard',    // 区域代理
                2: '/salesman/dashboard', // 业务员
                3: '/merchant/dashboard'  // 商家
              }
              const redirectPath = roleDashboardMap[userType]
              next({ path: redirectPath, replace: true })
            }
          }).catch(() => {
            next({ path: '/404' })
          })
        } else {
          // 路由已生成，检查当前路径是否与用户类型匹配
          const currentPath = to.path
          const rolePaths = {
            5: ['/admin/'],      // 总公司
            4: ['/agent/'],      // 区域代理
            2: ['/salesman/'],   // 业务员
            3: ['/merchant/']    // 商家
          }

          const allowedPaths = rolePaths[userType] || []
          const isRolePath = allowedPaths.some(pathPrefix => currentPath.startsWith(pathPrefix))

          // 如果当前路径不匹配用户类型，说明可能是上一个用户的路由，需要清除并重新生成
          if (currentPath !== '/aggregation-login' && currentPath !== '/login' && !isRolePath && currentPath !== '/' && currentPath !== '/index') {
            Logger.warn('检测到路由与用户类型不匹配，清除旧路由并重新生成', {
              currentPath,
              userType,
              allowedPaths
            })
            // 清除旧路由状态
            store.dispatch('permission/ResetRoutes').then(() => {
              // 重新生成路由
              return store.dispatch('GenerateRoutes')
            }).then(() => {
              // 重定向到角色首页
              const roleDashboardMap = {
                5: '/admin/dashboard',    // 总公司
                4: '/agent/dashboard',    // 区域代理
                2: '/salesman/dashboard', // 业务员
                3: '/merchant/dashboard'  // 商家
              }
              const redirectPath = roleDashboardMap[userType]
              next({ path: redirectPath, replace: true })
            }).catch(() => {
              next({ path: '/404' })
            })
            return
          }

          // 路由匹配，正常访问
          if (currentPath === '/' || currentPath === '/index') {
            const roleDashboardMap = {
              5: '/admin/dashboard',    // 总公司
              4: '/agent/dashboard',    // 区域代理
              2: '/salesman/dashboard', // 业务员
              3: '/merchant/dashboard'  // 商家
            }
            const redirectPath = roleDashboardMap[userType]
            next({ path: redirectPath, replace: true })
          } else {
            next()
          }
        }
      } else {
        // 若依系统用户或未识别的用户类型
        Logger.log('未识别的用户类型或若依系统用户', { userType })

        // 检查是否有聚合系统的用户信息
        const storedUserType = userStorage.getUserType()
        const storedUserPhone = userStorage.getUserPhone()

        if (storedUserType && storedUserPhone) {
          Logger.info('发现聚合系统用户信息，恢复用户状态')
          // 恢复聚合系统用户信息
          store.commit('SET_USER_TYPE', parseInt(storedUserType))
          store.commit('SET_USER_PHONE', storedUserPhone)

          // 生成路由并跳转（路由已在GenerateRoutes内部添加，无需重复添加）
          store.dispatch('GenerateRoutes').then(accessRoutes => {

            const roleDashboardMap = {
              5: '/admin/dashboard',    // 总公司
              4: '/agent/dashboard',    // 区域代理
              2: '/salesman/dashboard', // 业务员
              3: '/merchant/dashboard'  // 商家
            }
            const redirectPath = roleDashboardMap[parseInt(storedUserType)] || '/'
            next({ path: redirectPath, replace: true })
          }).catch(() => {
            next({ path: '/404' })
          })
        } else {
          // 若依系统用户
          if (store.getters.roles.length === 0) {
            isRelogin.show = true
            store.dispatch('GetInfo').then(() => {
              isRelogin.show = false
              store.dispatch('GenerateRoutes').then(accessRoutes => {
                router.addRoutes(accessRoutes)
                next({ ...to, replace: true })
              })
            }).catch(err => {
              store.dispatch('LogOut').then(() => {
                Message.error(err)
                next({ path: '/' })
              })
            })
          } else {
            next()
          }
        }
      }
    }
  } else {
    // 没有token
    if (whiteList.indexOf(to.path) !== -1) {
      // 在白名单中，直接通过
      next()
    } else {
      // 跳转到登录页
      next(`/aggregation-login?redirect=${encodeURIComponent(to.fullPath)}`)
      NProgress.done()
    }
  }
})

router.afterEach(() => {
  NProgress.done()
})
